#include "stdafx.h"
#include "CppUnitTest.h"
#include "LoadTestFunctions.h"

using namespace Microsoft::VisualStudio::CppUnitTestFramework;

namespace UnitTest
{		
    TEST_CLASS(UnitTestFATE)
    {
    public:
        TEST_METHOD(Test_libavcodec_dct_test_idct8x8)
        {
            static char* arguments[] = {NULL,"-i"};
            int r = CFFmpegTestFunctions::dct_test(1,arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_fft_4)
        {
            static char* arguments[] = {NULL,"-n4"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_ifft_4)
        {
            static char* arguments[] = {NULL,"-n4","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_mdct_4)
        {
            static char* arguments[] = {NULL,"-n4","-m"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_imdct_4)
        {
            static char* arguments[] = {NULL,"-n4","-m","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_rdft_4)
        {
            static char* arguments[] = {NULL,"-n4","-r"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_irdft_4)
        {
            static char* arguments[] = {NULL,"-n4","-r","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_dct1d_4)
        {
            static char* arguments[] = {NULL,"-n4","-d"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_idct1d_4)
        {
            static char* arguments[] = {NULL,"-n4","-d","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_fft_5)
        {
            static char* arguments[] = {NULL,"-n5"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_ifft_5)
        {
            static char* arguments[] = {NULL,"-n5","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_mdct_5 )
        {
            static char* arguments[] = {NULL,"-n5","-m"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_imdct_5 )
        {
            static char* arguments[] = {NULL,"-n5","-m","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_rdft_5 )
        {
            static char* arguments[] = {NULL,"-n5","-r"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_irdft_5 )
        {
            static char* arguments[] = {NULL,"-n5","-r","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_dct1d_5 )
        {
            static char* arguments[] = {NULL,"-n5","-d"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_idct1d_5 )
        {
            static char* arguments[] = {NULL,"-n5","-d","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_fft_6 )
        {
            static char* arguments[] = {NULL,"-n6"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_ifft_6 )
        {
            static char* arguments[] = {NULL,"-n6","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_mdct_6 )
        {
            static char* arguments[] = {NULL,"-n6","-m"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_imdct_6 )
        {
            static char* arguments[] = {NULL,"-n6","-m","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_rdft_6 )
        {
            static char* arguments[] = {NULL,"-n6","-r"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_irdft_6 )
        {
            static char* arguments[] = {NULL,"-n6","-r","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_dct1d_6 )
        {
            static char* arguments[] = {NULL,"-n6","-d"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_idct1d_6 )
        {
            static char* arguments[] = {NULL,"-n6","-d","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_fft_7 )
        {
            static char* arguments[] = {NULL,"-n7"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_ifft_7)
        {
            static char* arguments[] = {NULL,"-n7","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_mdct_7)
        {
            static char* arguments[] = {NULL,"-n7","-m"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_imdct_7)
        {
            static char* arguments[] = {NULL,"-n7","-m","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_rdft_7)
        {
            static char* arguments[] = {NULL,"-n7","-r"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_irdft_7)
        {
            static char* arguments[] = {NULL,"-n7","-r","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_dct1d_7)
        {
            static char* arguments[] = {NULL,"-n7","-d"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_idct1d_7)
        {
            static char* arguments[] = {NULL,"-n7","-d","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_fft_8)
        {
            static char* arguments[] = {NULL,"-n8"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_ifft_8)
        {
            static char* arguments[] = {NULL,"-n8","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_mdct_8)
        {
            static char* arguments[] = {NULL,"-n8","-m"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_imdct_8)
        {
            static char* arguments[] = {NULL,"-n8","-m","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_rdft_8)
        {
            static char* arguments[] = {NULL,"-n8","-r"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_irdft_8)
        {
            static char* arguments[] = {NULL,"-n8","-r","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_dct1d_8)
        {
            static char* arguments[] = {NULL,"-n8","-d"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_idct1d_8)
        {
            static char* arguments[] = {NULL,"-n8","-d","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_fft_9)
        {
            static char* arguments[] = {NULL,"-n9"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_ifft_9)
        {
            static char* arguments[] = {NULL,"-n9","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_mdct_9)
        {
            static char* arguments[] = {NULL,"-n9","-m"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_imdct_9)
        {
            static char* arguments[] = {NULL,"-n9","-m","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_rdft_9)
        {
            static char* arguments[] = {NULL,"-n9","-r"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_irdft_9)
        {
            static char* arguments[] = {NULL,"-n9","-r","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_dct1d_9)
        {
            static char* arguments[] = {NULL,"-n9","-d"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_idct1d_9)
        {
            static char* arguments[] = {NULL,"-n9","-d","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_fft_10)
        {
            static char* arguments[] = {NULL,"-n10"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_ifft_10)
        {
            static char* arguments[] = {NULL,"-n10","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_test_mdct_10)
        {
            static char* arguments[] = {NULL,"-n10","-m"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }	

        TEST_METHOD(Test_libavcodec_fft_test_imdct_10  )
        {
            static char* arguments[] = {NULL,"-n10","-m","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }	

        TEST_METHOD(Test_libavcodec_fft_test_rdft_10  )
        {
            static char* arguments[] = {NULL,"-n10","-r"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }	

        TEST_METHOD(Test_libavcodec_fft_test_irdft_10  )
        {
            static char* arguments[] = {NULL,"-n10","-r","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }	

        TEST_METHOD(Test_libavcodec_fft_test_dct1d_10  )
        {
            static char* arguments[] = {NULL,"-n10","-d"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }	

        TEST_METHOD(Test_libavcodec_fft_test_idct1d_10)
        {
            static char* arguments[] = {NULL,"-n10","-d","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }	

        TEST_METHOD(Test_libavcodec_fft_test_fft_11)
        {
            static char* arguments[] = {NULL,"-n11"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }	

        TEST_METHOD(Test_libavcodec_fft_test_ifft_11)
        {
            static char* arguments[] = {NULL,"-n11","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }	

        TEST_METHOD(Test_libavcodec_fft_test_mdct_11)
        {
            static char* arguments[] = {NULL,"-n11","-m"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }	

        TEST_METHOD(Test_libavcodec_fft_test_imdct_11)
        {
            static char* arguments[] = {NULL,"-n11","-m","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }	

        TEST_METHOD(Test_libavcodec_fft_test_rdft_11)
        {
            static char* arguments[] = {NULL,"-n11","-r"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }	

        TEST_METHOD(Test_libavcodec_fft_test_irdft_11)
        {
            static char* arguments[] = {NULL,"-n11","-r","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }	

        TEST_METHOD(Test_libavcodec_fft_test_dct1d_11)
        {
            static char* arguments[] = {NULL,"-n11","-d"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }	

        TEST_METHOD(Test_libavcodec_fft_test_idct1d_11)
        {
            static char* arguments[] = {NULL,"-n11","-d","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }	

        TEST_METHOD(Test_libavcodec_fft_test_fft_12)
        {
            static char* arguments[] = {NULL,"-n12"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }	

        TEST_METHOD(Test_libavcodec_fft_test_ifft_12)
        {
            static char* arguments[] = {NULL,"-n12","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }	

        TEST_METHOD(Test_libavcodec_fft_test_mdct_12)
        {
            static char* arguments[] = {NULL,"-n12","-m"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }	

        TEST_METHOD(Test_libavcodec_fft_test_imdct_12)
        {
            static char* arguments[] = {NULL,"-n12","-m","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }	

        TEST_METHOD(Test_libavcodec_fft_test_rdft_12)
        {
            static char* arguments[] = {NULL,"-n12","-r"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }	

        TEST_METHOD(Test_libavcodec_fft_test_irdft_12)
        {
            static char* arguments[] = {NULL,"-n12","-r","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }	

        TEST_METHOD(Test_libavcodec_fft_test_dct1d_12)
        {
            static char* arguments[] = {NULL,"-n12","-d"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }	

        TEST_METHOD(Test_libavcodec_fft_test_idct1d_12)
        {
            static char* arguments[] = {NULL,"-n12","-d","-i"};
            int r = CFFmpegTestFunctions::fft_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }	

        TEST_METHOD(Test_libavcodec_fft_fixed_4)
        {
            static char* arguments[]={NULL,"-n4"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_ifft_fixed_4)
        {
            static char* arguments[]={NULL,"-n4","-i"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_mdct_fixed_4)
        {
            static char* arguments[]={NULL,"-n4","-m"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_imdct_fixed_4)
        {
            static char* arguments[]={NULL,"-n4","-m","-i"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_fixed_5)
        {
            static char* arguments[]={NULL,"-n5"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_ifft_fixed_5)
        {
            static char* arguments[]={NULL,"-n5","-i"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_mdct_fixed_5)
        {
            static char* arguments[]={NULL,"-n5","-m"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_imdct_fixed_5)
        {
            static char* arguments[]={NULL,"-n5","-m","-i"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_fixed_6)
        {
            static char* arguments[]={NULL,"-n6"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_ifft_fixed_6)
        {
            static char* arguments[]={NULL,"-n6","-i"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_mdct_fixed_6)
        {
            static char* arguments[]={NULL,"-n6","-m"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_imdct_fixed_6)
        {
            static char* arguments[]={NULL,"-n6","-m","-i"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_fixed_7)
        {
            static char* arguments[]={NULL,"-n7"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_ifft_fixed_7)
        {
            static char* arguments[]={NULL,"-n7","-i"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_mdct_fixed_7)
        {
            static char* arguments[]={NULL,"-n7","-m"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_imdct_fixed_7)
        {
            static char* arguments[]={NULL,"-n7","-m","-i"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_fixed_8)
        {
            static char* arguments[]={NULL,"-n8"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_ifft_fixed_8)
        {
            static char* arguments[]={NULL,"-n8","-i"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_mdct_fixed_8)
        {
            static char* arguments[]={NULL,"-n8","-m"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_imdct_fixed_8)
        {
            static char* arguments[]={NULL,"-n8","-m","-i"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_fixed_9)
        {
            static char* arguments[]={NULL,"-n9"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_ifft_fixed_9)
        {
            static char* arguments[]={NULL,"-n9","-i"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_mdct_fixed_9)
        {
            static char* arguments[]={NULL,"-n9","-m"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_imdct_fixed_9)
        {
            static char* arguments[]={NULL,"-n9","-m","-i"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_fixed_10)
        {
            static char* arguments[]={NULL,"-n10"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_ifft_fixed_10)
        {
            static char* arguments[]={NULL,"-n10","-i"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_mdct_fixed_10)
        {
            static char* arguments[]={NULL,"-n10","-m"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_imdct_fixed_10)
        {
            static char* arguments[]={NULL,"-n10","-m","-i"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_fixed_11)
        {
            static char* arguments[]={NULL,"-n11"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_ifft_fixed_11)
        {
            static char* arguments[]={NULL,"-n11","-i"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_mdct_fixed_11)
        {
            static char* arguments[]={NULL,"-n11","-m"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_imdct_fixed_11)
        {
            static char* arguments[]={NULL,"-n11","-m","-i"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_fft_fixed_12)
        {
            static char* arguments[]={NULL,"-n12"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_ifft_fixed_12)
        {
            static char* arguments[]={NULL,"-n12","-i"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_mdct_fixed_12)
        {
            static char* arguments[]={NULL,"-n12","-m"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }

        TEST_METHOD(Test_libavcodec_imdct_fixed_12)
        {
            static char* arguments[]={NULL,"-n12","-m","-i"};
            int r = CFFmpegTestFunctions::fft_fixed_test(ARRAYSIZE(arguments),arguments);
            Assert::AreEqual(r,0);
        }
    };
}